#ifndef __M_SERVER_H__
#define __M_SERVER_H__
#include <iostream>
#include <vector>
#include <unordered_map>
#include <memory>
#include <cassert>
#include <cstring>
#include <functional>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>
#include <signal.h>
#include "any.hpp"
// 打印日志
#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL DBG
#define LOG(level, format, ...)\
    do\
    {\
        if (level < LOG_LEVEL)\
            break;\
        time_t t = time(NULL);\
        struct tm *ltm = localtime(&t);\
        char tmp[32] = {0};\
        strftime(tmp, 31, "%H:%M:%S", ltm);\
        fprintf(stdout, "[%p %s %s:%d] " format "\n", (void *)pthread_self(), tmp, __FILE__, __LINE__, ##__VA_ARGS__); \
    } while (0)

#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)
// 缓冲区
#define BUFFER_DEFAULT_SIZE 1024
class Buffer
{
private:
    std::vector<char> _buffer;//总的缓冲区
    uint64_t _readbuff;//读缓冲区大小
    uint64_t _writerbuff;//写缓冲区大小
public:
    Buffer() : _readbuff(0), _writerbuff(0), _buffer(BUFFER_DEFAULT_SIZE) {}//初始化
    // 起始地址
    char* Begin()
    {
        return &(*_buffer.begin());
    }
    // 写的起始地址
    char* GetWritePos()
    {
        return Begin() + _writerbuff;
    }
    // 读的起始地址
    char* GetReadPos()
    {
        return Begin() + _readbuff;
    }
    // 获取缓冲区末尾空闲空间大小--写偏移之后的空闲空间, 总体空间大小减去写偏移
    uint64_t TailIndexSize()
    {
        return _buffer.size() - _writerbuff;
    }
    // 获取缓冲区起始空闲空间大小--读偏移之前的空闲空间
    uint64_t HeadIndexSize()
    {
        return _readbuff;
    }
    // 获取可读数据大小 = 写偏移 - 读偏移
    uint64_t ReadIndexSize()
    {
        return _writerbuff - _readbuff;
    }
    // 将读偏移向后移动size大小
    void MoveReadOff(uint64_t size)
    {
        if (size == 0) return;
        // 向后移动的大小，必须小于可读数据大小
        assert(size <= ReadIndexSize());
        _readbuff += size;
    }
    // 将写偏移向后移动
    void MoveWriterOff(uint64_t size)
    {
        if (size == 0) return;
        assert(size <= TailIndexSize());
        _writerbuff += size;
    }
    //确保有足够的空间进行写
    void EnsureWriteSpace(uint64_t size)
    {
        // 末尾空间足够，直接返回
        if (TailIndexSize() >= size) return;
        if (TailIndexSize() + HeadIndexSize() >= size)
        {
            uint64_t rsz = ReadIndexSize();//写空间的大小
            std::copy(GetReadPos(), GetReadPos() + rsz, Begin());//直接复制
            _readbuff = 0;// 将读偏移归0
            _writerbuff = rsz; // 将写位置置为可读数据大小， 因为当前的可读数据大小就是写偏移量
        }
        else
        {
            // 总体空间不够，则需要扩容，不移动数据，直接给写偏移之后扩容足够空间即可
            DBG_LOG("RESIZE %ld", _writerbuff + size);//扩容
            _buffer.resize(_writerbuff + size);
        }
    }
    // 写数据
    void Write(const void* data, uint64_t size)
    {
        if (size == 0) return;
        EnsureWriteSpace(size);
        const char* wd = (const char* )data;
        std::copy(wd, wd + size, GetWritePos());
    }
    // 尾插
    void WritePush(const void* data, uint64_t size)
    {
        Write(data, size);
        MoveWriterOff(size);
    }
    //写string
    void WriteString(const std::string& data)
    {
        return Write(data.c_str(), data.size());
    }
    //写数据并插入
    void WriteStringAndPush(const std::string &data)
    {
        WriteString(data);
        MoveWriterOff(data.size());
    }
    void WriteBuffer(Buffer &data)
    {
        return Write(data.GetReadPos(), data.ReadIndexSize());
    }
    void WriteBufferAndPush(Buffer &data)
    {
        WriteBuffer(data);
        MoveWriterOff(data.ReadIndexSize());
    }
    // 读取数据
    void Read(void *buf, uint64_t size)
    {
        // 要求要获取的数据大小必须小于可读数据大小
        assert(size <= ReadIndexSize());
        std::copy(GetReadPos(), GetReadPos() + size, (char *)buf);
    }
    //读并删除
    void ReadAndPop(void *buf, uint64_t size)
    {
        Read(buf, size);
        MoveReadOff(size);
    }
    //读
    std::string ReadAsString(uint64_t size)
    {
        // 要求要获取的数据大小必须小于可读数据大小
        assert(size <= ReadIndexSize());
        std::string str;
        str.resize(size);
        Read(&str[0], size);
        return str;
    }
    //读
    std::string ReadAsStringAndPop(uint64_t size)
    {
        assert(size <= ReadIndexSize());
        std::string str = ReadAsString(size);
        MoveReadOff(size);
        return str;
    }
    //查找CRLF
    char* FindCRLF()
    {
        char* res = (char *)memchr(GetReadPos(), '\n', ReadIndexSize());//返回找到的地址
        return res;
    }
    std::string GetLine()
    {
        char *pos = FindCRLF();
        if (pos == NULL) return "";
        // +1是为了把换行字符也取出来。
        return ReadAsString(pos - GetReadPos() + 1);
    }
    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOff(str.size());
        return str;
    }
    // 清空缓冲区
    void Clear()
    {
        // 只需要将偏移量归0即可
        _readbuff = 0;
        _writerbuff = 0;
    }
};

#define MAX_LISTEN 1024
class Socket
{
private:
    int _socket;
public:
    Socket() : _socket(-1){}
    Socket(int socket) : _socket(socket){}
    ~Socket() { Close(); }
    int Fd() {return _socket;}
    // 创建socket
    bool Create()
    {
        _socket = socket(AF_INET, SOCK_STREAM, 0);
        if (_socket < 0)
        {
            ERR_LOG("CREATE SOCKET FAILED!!");
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip,const uint16_t &port)
    {
        struct sockaddr_in local;
        memset(&local, 0, sizeof local);
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(local);
        if (bind(_socket, (struct sockaddr *)&local, len) < 0)
        {
            ERR_LOG("BIND ADDRESS FAILED!");
            return false;
        }
        return true;
    }
    // 监听地址
    bool Listen(int backlog = MAX_LISTEN)
    {
        if (listen(_socket, backlog) < 0)
        {
            ERR_LOG("SOCKET LISTEN FAILED!");
            return false;
        }
        else return true;
    }
    // 请求连接
    bool Connect(const std::string& ip,const uint16_t& port)
    {
        struct sockaddr_in local;
        memset(&local, 0, sizeof local);
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(local);
        if (connect(_socket, (struct sockaddr *)&local, len) < 0) // 错误
        {
            ERR_LOG("BIND ADDRESS FAILED!");
            return false;
        }
        return true;
    }
    // 获取新链接
    int Accept()
    {
        int ret = accept(_socket, NULL, NULL);
        if (ret < 0)
        {
            ERR_LOG("BIND ADDRESS FAILED!");
            return -1;
        }
        return ret;
    }
    // 读取数据
    bool Recv(char *buf, ssize_t size, int flag = 0)
    {
        int n = recv(_socket, buf, size, flag);
        if (n <= 0)
        {
            if (errno == EAGAIN || n == EINTR) return 0; // 这次没有数据
            return false;
        }
        return true;
    }
    // 非阻塞读取
    bool NoneBlockRecv(char *buf, ssize_t size)
    {
        if (size == 0) return 0;
        Recv(buf, size, MSG_DONTWAIT); // MSG_DONTWAIT表示当前为非阻塞
    }
    // 发送
    bool Send(const char* buf, ssize_t size, int flag = 0)
    {
        int n = send(_socket, buf, size, flag);
        if (n <= 0)
        {
            if (errno == EAGAIN || n == EINTR) return 0; // 这次没有数据
            return false;
        }
        return true;
    }
    // 非阻塞发送
    bool NoneBlockSend(char *buf, size_t size)
    {
        if (size == 0) return 0;
        Send(buf, size, MSG_DONTWAIT);
    }
    // 关闭
    void Close()
    {
        if (_socket >= 0)
        {
            close(_socket);
            _socket = -1;
        }
    }
    // 创建服务段端
    bool CreateServer(const uint16_t& port, const std::string& ip = "0.0.0.0", bool block_flag = false)
    {
        if (Create() == false) return false;
        if (block_flag) NoneBlock(); // 设为非阻塞状态
        if (Bind(ip, port) == false) return false;
        if (Listen() == false) return false;
        ReuseAddress();
        return true;
    }
    // 创建客户端
    bool CreateClient(const uint16_t& port, const std::string& ip = "0.0.0.0")
    {
        // 1. 创建套接字，2.指向连接服务器
        if (Create() == false) return false;
        if (Connect(ip, port) == false) return false;
        return true;
    }
    // 开启地址端口重用
    void ReuseAddress()
    {
        int val = 1;
        setsockopt(_socket, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int));
        val = 1;
        setsockopt(_socket, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int));
    }
    // 非阻塞
    void NoneBlock()
    {
        int flag = fcntl(_socket, F_GETFL, 0);
        fcntl(_socket, F_SETFL, flag | O_NONBLOCK);
    }
};

class Poller;    // 监控事件
class EventLoop; // 处理事件
class Channel
{
private:
    int _fd;
    EventLoop *_loop;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前需要触发的时间
    using FuncCall = std::function<void()>;
    FuncCall _readcall;
    FuncCall _writecall;
    FuncCall _errorcall;
    FuncCall _closecall;
    FuncCall _eventcall;

public:
    Channel() {}
    Channel(int fd, EventLoop* loop) : _fd(fd), _loop(loop) {}
    // 当前文件
    int Fd()
    {
        return _fd;
    }
    uint32_t Events() { return _events; } // 需要监控的文件
    void SetRevents(uint32_t events)
    {
        _revents = events;
    }
    void SetReadCallback(const FuncCall &readcall)
    {
        _readcall = readcall;
    }
    void SetWriteCallback(const FuncCall &writecall)
    {
        _writecall = writecall;
    }
    void SetErrorCallback(const FuncCall &errorcall)
    {
        _errorcall = errorcall;
    }
    void SetCloseCallback(const FuncCall &closecall)
    {
        _closecall = closecall;
    }
    void SetEventCallback(const FuncCall &eventcall)
    {
        _eventcall = eventcall;
    }
    // 当前是否监控了可读
    bool ReadAble()
    {
        return _events & EPOLLIN;
    }
    // 当前是否监控了可写
    bool WriteAble()
    {
        return (_events & EPOLLOUT);
    }
    // 启动读事件监控
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update();
    }
    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }
    // 关闭读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }
    // 关闭所有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }
    // 移除监控
    void Remove();
    void Update();
    // 事件处理，一旦连接触发了事件，就调用这个函数，自己触发了什么事件如何处理自己决定
    void HandleEvent()
    {
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            /*不管任何事件，都调用的回调函数*/
            if (_readcall) _readcall();
        }
        /*有可能会释放连接的操作事件，一次只处理一个*/
        if (_revents & EPOLLOUT)
        {
            if (_writecall) _writecall();
        }
        else if (_revents & EPOLLERR)
        {
            if (_errorcall) _errorcall(); // 一旦出错，就会释放连接，因此要放到前边调用任意回调
        }
        else if (_revents & EPOLLHUP)
        {
            if (_closecall) _closecall();
        }
        if (_eventcall) _eventcall();
    }
};
#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _efd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel*> _channels;
private:
    // 查询
    bool HasChannel(Channel* channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end()) return true;
        return false;
    }
    // 更新
    void Update(Channel* channel, int op)
    {
        struct epoll_event ev;
        int fd=channel->Fd();
        ev.events = channel->Events();
        ev.data.fd = fd;
        std::cout<<"fd:"<<fd<<std::endl;
        if (epoll_ctl(_efd, op, fd, &ev) < 0)
        {
            //ERR_LOG("epoll_ctl error");
            ERR_LOG("epoll_ctl error:%s\n", strerror(errno));
            //abort();
        }
        return;
    }

public:
    Poller()
    {
        int _efd = epoll_create(MAX_EPOLLEVENTS);
        if (_efd < 0)
        {
            ERR_LOG("epoll_create error");
            abort(); // 退出程序
        }
    }
    // 更新或修改事件
    void UpdateEvent(Channel *channel)
    {
        if (HasChannel(channel) == true)
        {
            _channels.insert({channel->Fd(), channel});
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 删除事件
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end()) _channels.erase(it);
        Update(channel, EPOLL_CTL_DEL);
    }

    void Poll(std::vector<Channel*>* active)
    {
        int ndfs = epoll_wait(_efd, _evs, MAX_EPOLLEVENTS, -1);
        if (ndfs < 0)
        {
            if (errno == EINTR) return;
            ERR_LOG("EPOLL WAIT ERROR:%s\n", strerror(errno));
            abort(); // 退出程序
        }
        for (int i = 0; i < ndfs; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetRevents(_evs[i].events); // 设置实际就绪的事件
            active->push_back(it->second);
        }
        return;
    }
};

using TaskFunc = std::function<void()>;
using RelaseFunc = std::function<void()>;
class TimeTask
{
private:
    uint64_t _id;           // 定时器任务ID
    uint32_t _timeout;      // 超时时间
    TaskFunc _task;         // 执行任务
    RelaseFunc _rtask;      // 时间到需要清理的任务
    bool _canceled = false; // 是否被清理 true被清理
public:
    TimeTask(uint64_t id, uint32_t timeout, TaskFunc task)
        : _id(id), _timeout(timeout), _task(task)
    {}
    ~TimeTask()
    {
        if (_canceled == false) _task();
        _rtask();
    }
    void SetRelaseFunc(const RelaseFunc &cb) 
    { 
        _rtask = cb; 
    }
    void Cancel() 
    { 
        _canceled = true; 
    }
    uint32_t DelayTime() 
    { 
        return _timeout; 
    }
};
using WeakTask = std::weak_ptr<TimeTask>;
using PtrTask = std::shared_ptr<TimeTask>;
class Timerwheel // 时间轮
{
private:
    int _tick;     // 秒针，走到哪里，到哪里释放任务
    int _capacity; // 最大容量
    std::vector<std::vector<PtrTask>> _wheel;
    std::unordered_map<uint64_t, WeakTask> _timers;

    EventLoop *_loop;
    int _timerfd; // 定时器描述符--可读事件回调就是读取计数器，执行定时任务
    std::unique_ptr<Channel> _timerchannel;

public:
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end()) _timers.erase(it);
    }
    static int CreateTimerfd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            ERR_LOG("TIMERFD CREATE FAILED!");
            abort();
        }
        // int timerfd_settime(int fd, int flags, struct itimerspec *new, struct itimerspec *old);
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0; // 第一次超时时间为1s后
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0; // 第一次超时后，每次超时的间隔时
        timerfd_settime(timerfd, 0, &itime, nullptr);
        return timerfd;
    }

    int ReadTimefd()
    {
        uint64_t times = 1;
        int ret = read(_timerfd, &times, 0);
        if (ret < 0)
        {
            ERR_LOG("READ TIMEFD FAILED!");
            abort();
        }
        return ret;
    }

    void OneTime()
    {
        // 根据实际超时的次数，执行对应的超时任务
        int times = ReadTimefd();
        for (int i = 0; i < times; i++)
            RunTimerTask();
    }

    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        PtrTask pt(new TimeTask(id, delay, cb));
        pt->SetRelaseFunc(std::bind(&Timerwheel::RemoveTimer, this, id));
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
        _timers[id] = WeakTask(pt);
    }
    void TimerRefreshInLoop(uint64_t id)
    {
        // 通过保存的定时器对象的weak_ptr构造一个shared_ptr出来，添加到轮子中
        auto it = _timers.find(id);
        if (it == _timers.end()) return; // 没找着定时任务，没法刷新，没法延迟
        PtrTask pt = it->second.lock(); // lock获取weak_ptr管理的对象对应的shared_ptr
        int delay = pt->DelayTime();
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }
    void TimerCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end()) return; // 没找着定时任务，没法刷新，没法延迟
        PtrTask pt = it->second.lock();
        if (pt) pt->Cancel();
    }

public:
    Timerwheel(EventLoop *loop)
        : _tick(0), _capacity(60), _wheel(_capacity), _loop(loop), _timerfd(CreateTimerfd()), _timerchannel(new Channel(_timerfd, _loop))
    {
        _timerchannel->SetReadCallback(std::bind(&Timerwheel::OneTime, this));
        _timerchannel->EnableRead(); // 启动读事件监控
    }
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cd);
    // 刷新/延迟定时任务
    void TimerRefresh(uint64_t id);
    void TimerCancel(uint64_t id); // 取消任务

    void RunTimerTask() // 向后走
    {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空指定位置的数组，就会把数组中保存的所有管理定时器对象的shared_ptr释放掉
    }
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end()) return false;
        return true;
    }
};

class EventLoop
{
private:
    using Functor = std::function<void()>;
    std::thread::id _threadid; // 线程id
    int _eventfd;              // 唤醒事件可能导致的阻塞
    std::unique_ptr<Channel> _eventchannel;
    Poller _poller;              // 进行所有描述符的事件监控
    std::vector<Functor> _tasks; // 任务池
    std::mutex _mutex;           // 实现任务池操作的线程安全
    Timerwheel _timerwheel;      // 定时器模块
public:
    void ReadEventfd()
    {
        uint64_t res = 0;
        int ret = read(_eventfd, &res, 0);
        if (ret <= 0)
        {
            if (errno == EINTR || errno == EAGAIN) return;
            ERR_LOG("READ EVENTFD FAILED!");
            abort();
        }
        return;
    }
    static int CreateEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            ERR_LOG("CREATE EVENTFD FAILED!!");
            abort(); // 让程序异常退出
        }
        return efd;
    }
    void RunAllTask()
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex); // 加锁，防止线程安全
            _tasks.swap(functor);
        }
        for (auto &f : functor)
            f();
        return;
    }
    void WeakUpEventFd()
    {
        uint64_t val = 1;
        int ret = write(_eventfd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR) return;
            ERR_LOG("READ EVENTFD FAILED!");
            abort();
        }
        return;
    }

public:
    EventLoop()
        : _threadid(std::this_thread::get_id()), _eventfd(CreateEventFd()), _eventchannel(new Channel(_eventfd, this)), _timerwheel(this)
    {
        // 给eventfd添加可读事件回调函数，读取eventfd事件通知次数
        _eventchannel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this));
        // 启动eventfd的读事件监控
        _eventchannel->EnableRead();
    }
    void Start()
    {
        while (1)
        {
            // 1.事件监控
            std::vector<Channel*> actives;
            _poller.Poll(&actives);
            // 事件处理
            for (auto& channel: actives)
            {
                channel->HandleEvent();
            }
            // 执行任务
            RunAllTask();
        }
    }
    bool IsLoop()
    {
        // 判断当前线程是否为是要处理的任务
        return (_threadid == std::this_thread::get_id());
    }
    void AssertInLoop()
    {
        assert(_threadid == std::this_thread::get_id());
    }
    // 判断将要执行的任务是否处于当前线程中，如果是则执行，不是则压入队列。
    void RunInLoop(const Functor &cb)
    {
        if (IsLoop()) return;
        // AssertInLoop();
        return QueueInLoop(cb);
    }
    void QueueInLoop(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪，而导致的epoll阻塞；
        // 其实就是给eventfd写入一个数据，eventfd就会触发可读事件
        WeakUpEventFd();
    }
    // 添加/修改描述符的事件监控
    void UpdateEvent(Channel *channel) 
    { 
        return _poller.UpdateEvent(channel); 
    }
    // 移除描述符的监控
    void RemoveEvent(Channel *channel) 
    { 
        return _poller.RemoveEvent(channel); 
    }
    // 事件添加
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb) 
    { 
        return _timerwheel.TimerAdd(id, delay, cb); 
    }
    // 事件更新
    void TimerRefresh(uint64_t id) 
    { 
        return _timerwheel.TimerRefresh(id); 
    }
    // 取消事件
    void TimerCancel(uint64_t id) 
    { 
        return _timerwheel.TimerCancel(id); 
    }
    // 是否存在
    bool HasTimer(uint64_t id) 
    { 
        return _timerwheel.HasTimer(id); 
    }
};

class LoopThread
{
private:
    /*用于实现_loop获取的同步关系，避免线程创建了，但是_loop还没有实例化之前去获取_loop*/
    std::mutex _mutex;             // 互斥锁
    std::condition_variable _cond; // 条件变量
    EventLoop *_loop;              // EventLoop指针变量，这个对象需要在线程内实例化
    std::thread _thread;           // EventLoop对应的线程
private:
    /*实例化 EventLoop 对象，唤醒_cond上有可能阻塞的线程，并且开始运行EventLoop模块的功能*/
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }

public:
    LoopThread() : _loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}
    //返回当前线程关联的EventLoop对象指针
    EventLoop* GetLoop()
    {
        EventLoop* loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _cond.wait(lock, [&](){ return _loop != NULL; }); // loop为NULL就一直阻塞
            loop = _loop;
        }
        return loop;
    }
};
class LoopThreadPool
{
private:
    int _thread_count;//事件
    int _next_id;//下一个
    EventLoop* _baseloop;//
    std::vector<LoopThread*> _threads;//线程
    std::vector<EventLoop*> _loops;//事件
public:
    LoopThreadPool(EventLoop* baseloop) : _thread_count(0), _next_id(0), _baseloop(baseloop) {}
    void SetThreadCount(int count) { _thread_count = count; }
    void Create()
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
        return;
    }
    EventLoop* NextLoop()
    {
        if (_thread_count == 0)
        {
            return _baseloop;
        }
        _next_id = (_next_id + 1) % _thread_count;
        return _loops[_next_id];
    }
};

// DISCONECTED -- 连接关闭状态；   CONNECTING -- 连接建立成功-待处理状态
// CONNECTED -- 连接建立完成，各种设置已完成，可以通信的状态；  DISCONNECTING -- 待关闭状态
class Connection;
typedef enum
{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    DISCONNECTING
} ConnStatu;
using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    uint64_t _connid;              // 连接的id，便于查找和管理
    int _sockfd;                   // 连接的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志，默认为false
    EventLoop* _loop;              // 连接所关联的一个EventLoop
    ConnStatu _statu;              // 连接状态
    Socket _socket;                // 套接字操作管理
    Channel _channel;              // 连接的事件管理
    Buffer _in_buff;               // 输入缓冲区---存放从socket中读取到的数据
    Buffer _out_buff;              // 输出缓冲区---存放要发送给对端的数据
    Any _context;                  // 请求的接收处理上下文
    using ConnectedCallback = std::function<void(const PtrConnection& )>;
    using MessageCallback = std::function<void(const PtrConnection&, Buffer* )>;
    using ClosedCallback = std::function<void(const PtrConnection& )>;
    using AnyEventCallback = std::function<void(const PtrConnection& )>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
    /*就应该从管理的地方移除掉自己的信息*/
    ClosedCallback _server_closed_callback;

private:
    void HandleRead()
    {
        char buf[1024];
        ssize_t ret = _socket.NoneBlockRecv(buf, 65535);
        if (ret < 0) return ShutdownInLoop(); // 出错了,不能直接关闭连接
        // 这里的等于0表示的是没有读取到数据，而并不是连接断开了，连接断开返回的是-1
        // 将数据放入输入缓冲区,写入之后顺便将写偏移向后移动
        _in_buff.WritePush(buf, ret);
        // 2. 调用message_callback进行业务处理
        if (_in_buff.ReadIndexSize() > 0)
        {
            // shared_from_this--从当前对象自身获取自身的shared_ptr管理对象
            return _message_callback(shared_from_this(), &_in_buff);
        }
    }
    // 描述符可写事件触发后调用的函数，将发送缓冲区中的数据进行发送
    void HandleWriter()
    {
        //_out_buffer中保存的数据就是要发送的数据
        ssize_t ret = _socket.NoneBlockSend(_out_buff.GetReadPos(), _out_buff.ReadIndexSize());
        if (ret < 0)
        {
            // 发送错误就该关闭连接了，
            if (_in_buff.ReadIndexSize() > 0)
            {
                _message_callback(shared_from_this(), &_in_buff);
            }
            return Release(); // 这时候就是实际的关闭释放操作了。
        }
        _out_buff.MoveReadOff(ret); // 千万不要忘了，将读偏移向后移动
        if (_out_buff.ReadIndexSize() == 0)
        {
            _channel.DisableWrite(); // 没有数据待发送了，关闭写事件监控
            // 如果当前是连接待关闭状态，则有数据，发送完数据释放连接，没有数据则直接释放
            if (_statu == DISCONNECTING) return Release();
        }
        return;
    }
    // 描述符触发挂断事件()
    void HandleClose()
    {
        if (_in_buff.ReadIndexSize() > 0)
            _message_callback(shared_from_this(), &_in_buff);
        return Release();
    }
    // 处理错误事件
    void HandleError()
    {
        return HandleClose();
    }
    // 描述符触发任意事件: 1. 刷新连接的活跃度--延迟定时销毁任务；  2. 调用组件使用者的任意事件回调
    void HandleEvent()
    {
        if (_enable_inactive_release == true)
            _loop->TimerRefresh(_connid);
        if (_event_callback)
            _event_callback(shared_from_this());
    }
    // 连接获取之后，所处的状态下要进行各种设置（启动读监控,调用回调函数）
    void EstablishedInLoop()
    {
        // 1. 修改连接状态；  2. 启动读事件监控；  3. 调用回调函数
        assert(_statu == CONNECTING); // 当前的状态必须一定是上层的半连接状态
        _statu = CONNECTED;           // 当前函数执行完毕，则连接进入已完成连接状态
        // 一旦启动读事件监控就有可能会立即触发读事件，如果这时候启动了非活跃连接销毁
        _channel.EnableRead();
        if (_connected_callback)
            _connected_callback(shared_from_this());
    }
    // 这个接口才是实际的释放接口
    void ReleaseInLoop()
    {
        // 1. 修改连接状态，将其置为DISCONNECTED
        _statu = DISCONNECTED;
        // 2. 移除连接的事件监控
        _channel.Remove();
        // 3. 关闭描述符
        _socket.Close();
        // 4. 如果当前定时器队列中还有定时销毁任务，则取消任务
        if (_loop->HasTimer(_connid))
            CancelInactiveReleaseInLoop();
        // 5. 调用关闭回调函数，避免先移除服务器管理的连接信息导致Connection被释放，再去处理会出错，因此先调用用户的回调函数
        if (_closed_callback)
            _closed_callback(shared_from_this());
        // 移除服务器内部管理的连接信息
        if (_server_closed_callback)
            _server_closed_callback(shared_from_this());
    }
    // 这个接口并不是实际的发送接口，而只是把数据放到了发送缓冲区，启动了可写事件监控
    void SendInLoop(Buffer& buf)
    {
        if (_statu == DISCONNECTED) return;
        _out_buff.WriteBufferAndPush(buf);
        if (_channel.WriteAble() == false)
        {
            _channel.EnableWrite();
        }
    }
    // 这个关闭操作并非实际的连接释放操作，需要判断还有没有数据待处理，待发送
    void ShutdownInLoop()
    {
        _statu = DISCONNECTING; // 设置连接为半关闭状态
        if (_in_buff.ReadIndexSize() > 0)
        {
            if (_message_callback) _message_callback(shared_from_this(), &_in_buff);
        }
        // 要么就是写入数据的时候出错关闭，要么就是没有待发送数据，直接关闭
        if (_out_buff.ReadIndexSize() > 0)
        {
            if (_channel.WriteAble() == false)
            {
                _channel.EnableWrite();
            }
        }
        if (_out_buff.ReadIndexSize() == 0) Release();
    }
    // 启动非活跃连接超时释放规则
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1. 将判断标志 _enable_inactive_release 置为true
        _enable_inactive_release = true;
        // 2. 如果当前定时销毁任务已经存在，那就刷新延迟一下即可
        if (_loop->HasTimer(_connid))
        {
            return _loop->TimerRefresh(_connid);
        }
        // 3. 如果不存在定时销毁任务，则新增
        _loop->TimerAdd(_connid, sec, std::bind(&Connection::Release, this));
    }
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_connid))
        {
            _loop->TimerCancel(_connid);
        }
    }
    void UpgradeInLoop(const Any& context, const ConnectedCallback& conn,
                       const MessageCallback& msg, const ClosedCallback& closed,
                       const AnyEventCallback& event)
    {
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }

public:
    Connection(EventLoop* loop, uint64_t connid, int sockfd)
        : _loop(loop), _connid(connid), _sockfd(sockfd), _enable_inactive_release(false), _statu(CONNECTING), _socket(_sockfd)
    {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWriter, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }
    ~Connection()
    {
        DBG_LOG("RELEASE CONNECTION:%p", this);
    }
    // 获取管理的文件描述符
    int Fd() 
    { 
        return _sockfd; 
    }
    // 获取连接ID
    int Id() 
    { 
        return _connid; 
    }
    // 是否处于CONNECTED状态
    bool Connected() 
    { 
        return (_statu == CONNECTED); 
    }
    // 设置上下文--连接建立完成时进行调用
    void SetContext(const Any& context) 
    { 
        _context = context; 
    }
    // 获取上下文，返回的是指针
    Any *GetContext() 
    { 
        return &_context; 
    }
    void SetConnectedCallback(const ConnectedCallback& cb) 
    { 
        _connected_callback = cb;
    }
    void SetMessageCallback(const MessageCallback& cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback& cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback& cb) { _event_callback = cb; }
    void SetSrvClosedCallback(const ClosedCallback& cb) { _server_closed_callback = cb; }
    // 连接建立就绪后，进行channel回调设置，启动读监控，调用_connected_callback
    void Established()
    {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }
    // 发送数据，将数据放到发送缓冲区，启动写事件监控
    void Send(const char* data, size_t len)
    {
        // 外界传入的data，可能是个临时的空间，我们现在只是把发送操作压入了任务池，有可能并没有被立即执行
        // 因此有可能执行的时候，data指向的空间有可能已经被释放了。
        Buffer buf;
        buf.WritePush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
    // 提供给组件使用者的关闭接口--并不实际关闭，需要判断有没有数据待处理
    void Shutdown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }
    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }
    // 启动非活跃销毁，并定义多长时间无通信就是非活跃，添加定时任务
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }
    // 取消非活跃销毁
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }
    // 切换协议---重置上下文以及阶段性回调处理函数 -- 而是这个接口必须在EventLoop线程中立即执行
    // 防备新的事件触发后，处理的时候，切换任务还没有被执行--会导致数据使用原协议处理了。
    void Upgrade(const Any& context, const ConnectedCallback& conn, const MessageCallback& msg,
                 const ClosedCallback& closed, const AnyEventCallback& event)
    {
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }
};

class Acceptor
{
private:
    Socket _socket;//用于创建socket
    EventLoop* _loop;//用于对监听套接字进行事件监控
    Channel _channel;//用于对监听套接字进行事件管理

    using AcceptCallback = std::function<void(int)>;
    AcceptCallback _accept_callback;
private:
    void HandleRead()
    {
        int fd=_socket.Accept();
        if(fd < 0) return;
        if (_accept_callback) _accept_callback(fd);
    }
    int Creatserver(uint16_t port)
    {
        bool ret=_socket.CreateServer(port);
        assert(ret==true);
        return _socket.Fd();
    }
public:
    /*不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动*/
    /*否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏*/
    Acceptor(EventLoop* loop, uint16_t port) 
    : _socket(Creatserver(port)), _loop(loop)
    ,_channel(_socket.Fd(), loop)
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
    }
    void SetAcceptCallback(const AcceptCallback &cb) { _accept_callback = cb; }
    void Listen() { _channel.EnableRead(); }
};

class TcpServer
{
private:
    uint64_t _nextid;//自增id
    int _port;//端口号
    int _timeout;//超时时间
    bool _enable_inactive_release;//是否启动活跃链接超时销毁
    EventLoop _baseloop;//主线程Eventloop对象，负责监听
    Acceptor  _accept;//监听套接字的管理对象
    LoopThreadPool _pool;//从属线程池
    std::unordered_map<uint64_t, PtrConnection> _conns;//保存管理所有连接对应的shared_ptr对象
    //回调函数
    using ConnectedCallback = std::function<void(const PtrConnection&)>;
    using MessageCallback = std::function<void(const PtrConnection&, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection&)>;
    using AnyEventCallback = std::function<void(const PtrConnection&)>;
    using Functor = std::function<void()>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
private:
    void RunAfterInLoop(const Functor& task, int delay)//下一个运行的任务
    {
        _nextid++;
        _baseloop.TimerAdd(_nextid, delay, task);
    }
    //为新连接构造一个Connection进行管理
    void NewConnect(int fd)
    {
        _nextid++;
        PtrConnection conn(new Connection(_pool.NextLoop(), _nextid, fd));
        conn->SetMessageCallback(_message_callback);
        conn->SetClosedCallback(_closed_callback);
        conn->SetConnectedCallback(_connected_callback);
        conn->SetAnyEventCallback(_event_callback);
        conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release) 
            conn->EnableInactiveRelease(_timeout);//启动非活跃超时销毁
        conn->Established();//就绪初始化
        _conns.insert(std::make_pair(_nextid, conn));
    }
    void RemoveConnectionInLoop(const PtrConnection& conn) 
    {
        int id = conn->Id();
        auto it = _conns.find(id);
        if (it != _conns.end()) 
        {
            _conns.erase(it);
        }
    }
    //从管理Connection的_conns中移除连接信息
    void RemoveConnection(const PtrConnection& conn) 
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }
public:
    TcpServer(int port)
    :_port(port),_nextid(0),_enable_inactive_release(false)
    , _accept(&_baseloop, port),_pool(&_baseloop)
    {
        _accept.SetAcceptCallback(std::bind(&TcpServer::NewConnect, this, std::placeholders::_1));
        _accept.Listen();//将监听套接字挂到baseloop上

    }
    void SetThreadCount(int count) { return _pool.SetThreadCount(count); }
    void SetConnectedCallback(const ConnectedCallback&cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback&cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback&cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback&cb) { _event_callback = cb; }
    void EnableInactiveRelease(int timeout) { _timeout = timeout; _enable_inactive_release = true; }
    //用于添加一个定时任务
    void RunAfter(const Functor& task, int delay) 
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }
    void Start() 
    { 
        _pool.Create();  
        _baseloop.Start(); 
    }


};
void Channel::Remove() { return _loop->RemoveEvent(this); }
void Channel::Update() { return _loop->UpdateEvent(this); }
void Timerwheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&Timerwheel::TimerAddInLoop, this, id, delay, cb));
}
// 刷新/延迟定时任务
void Timerwheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&Timerwheel::TimerRefreshInLoop, this, id));
}
void Timerwheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&Timerwheel::TimerCancelInLoop, this, id));
}

class NetWork
{
public:
    NetWork()
    {
        /*避免服务器因为给断开连接的客户端进行send触发异常导致程序崩溃，因此忽略SIGPIPE信号*/
        /*定义静态全局是为了保证构造函数中的信号忽略处理能够在程序启动阶段就被直接执行*/
        DBG_LOG("SIGPIPE INIT");
        signal(SIGPIPE,SIG_IGN);
    }
};
static NetWork nw;


#endif //__SERVER_H__